"""
lst = map(str, list(range(9)))
print(lst)

print(",".join(lst))

# 定义一个包含字符串元素的列表
fruits = ["apple", "banana", "orange", "grape"]
print("字符串列表:", fruits)

# 使用逗号作为分隔符将列表元素连接成一个字符串
# separator是逗号，iterable是fruits列表
comma_joined = ",".join(fruits)
print("逗号连接:", comma_joined)

# 例1：按照空格分割
s = "hello world python"
print(s.split())  # ['hello', 'world', 'python']

# 例2：按照其它字符分割
data = "2024-06-01"
print(data.split("-"))  # ['2024', '06', '01']

# 例3：使用maxsplit参数
record = "id,name,age,gender"
print(record.split(",", maxsplit=2))  # ['id', 'name', 'age,gender']

# 例4：多种空白字符自动分割
multi_space = "one\t two   three\nfour"
print(multi_space.split())  # ['one', 'two', 'three', 'four']

str = "mY NaMe"
print(str.title())  # My Name
print(str.capitalize())  # My name
print(str.lower())  # my name
print(str.upper())  # MY NAME
print(str.swapcase())  # My nAmE
# 定义一个包含特殊字符的字符串
string = "straße"
print("原始字符串:")
print(f"'{string}'")

# 使用casefold()方法转换
casefold_string = string.casefold()
print("\n使用casefold()转换后:")
print(f"'{casefold_string}'")

# 验证转换结果
print(f"\n原始字符串长度: {len(string)}")
print(f"转换后字符串长度: {len(casefold_string)}")
print(f"字符串是否发生变化: {string != casefold_string}")

# 处理不同类型的字符串
print("\n=== 处理不同类型的字符串 ===")

# 德语字符串
german_string = "Grüße"
print(f"德语字符串: '{german_string}'")
print(f"casefold转换: '{german_string.casefold()}'")

# 法语字符串
french_string = "Café"
print(f"法语字符串: '{french_string}'")
print(f"casefold转换: '{french_string.casefold()}'")

# 土耳其语字符串
turkish_string = "İstanbul"
print(f"土耳其语字符串: '{turkish_string}'")
print(f"casefold转换: '{turkish_string.casefold()}'")

# 希腊语字符串
greek_string = "ΣΟΦΙΑ"
print(f"希腊语字符串: '{greek_string}'")
print(f"casefold转换: '{greek_string.casefold()}'")

# 普通英文字符串
english_string = "Hello, World!"
print(f"英文字符串: '{english_string}'")
print(f"casefold转换: '{english_string.casefold()}'")

# casefold()与lower()方法的区别
print("=== casefold()与lower()方法的区别 ===")

# 测试字符串
test_strings = ["straße", "Grüße", "Café", "İstanbul", "ΣΟΦΙΑ", "Hello World"]

print("字符串\t\tlower()\t\tcasefold()")
print("-" * 50)

for string in test_strings:
    lower_result = string.lower()
    casefold_result = string.casefold()
    print(f"'{string}'\t\t'{lower_result}'\t\t'{casefold_result}'")

# 国际化字符串比较
print("\n=== 国际化字符串比较 ===")


def case_insensitive_compare_lower(str1, str2):
    return str1.lower() == str2.lower()


def case_insensitive_compare_casefold(str1, str2):
    return str1.casefold() == str2.casefold()


# 测试比较
test_pairs = [
    ("straße", "STRASSE"),
    ("Grüße", "GRÜSSE"),
    ("Café", "CAFÉ"),
    ("İstanbul", "ISTANBUL"),
]

for str1, str2 in test_pairs:
    lower_result = case_insensitive_compare_lower(str1, str2)
    casefold_result = case_insensitive_compare_casefold(str1, str2)
    print(f"'{str1}' == '{str2}':")
    print(f"  lower()比较: {lower_result}")
    print(f"  casefold()比较: {casefold_result}")
    print()


# 使用索引反转字符串
string = "Hello, World!"
reversed_string = string[::-1]
print(reversed_string)  # !dlroW ,olleH
# 使用reversed()函数反转字符串
string = "Hello, World!"
reversed_string = ''.join(reversed(string))
print(reversed_string)  # !dlroW ,olleH
# 使用循环反转字符串
string = "Hello, World!"
reversed_string = ''
for char in string:
    reversed_string = char + reversed_string
print(reversed_string)  # !dlroW ,olleH
# 使用栈反转字符串
string = "Hello, World!"
stack = list(string)
reversed_string = ''
while stack:
    reversed_string += stack.pop()
print(reversed_string)  # !dlroW ,olleH
# 使用递归反转字符串
def reverse_string_recursive(s):
    if len(s) == 0:
        return s
    else:
        return s[-1] + reverse_string_recursive(s[:-1])
string = "Hello, World!"
reversed_string = reverse_string_recursive(string)
print(reversed_string)  # !dlroW ,olleH
# 使用列表反转字符串
string = "Hello, World!"
char_list = list(string)
char_list.reverse()
reversed_string = ''.join(char_list)
print(reversed_string)  # !dlroW ,olleH


# python的成员运算符示例
# 定义一个字符串
str_example = "Hello, World!"
# 检查子字符串是否在字符串中
print("World" in str_example)  # 输出: True
print("Python" not in str_example)  # 输出: True
# 定义一个列表
list_example = [1, 2, 3, 4, 5]
# 检查元素是否在列表中
print(3 in list_example)  # 输出: True
print(6 not in list_example)  # 输出: True
# 定义一个字典
dict_example = {"a": 1, "b": 2, "c": 3}
# 检查键是否在字典中
print("b" in dict_example)  # 输出: True
print("d" not in dict_example)  # 输出: True
# 定义一个集合
set_example = {10, 20, 30, 40, 50}
# 检查元素是否在集合中
print(20 in set_example)  # 输出: True
print(60 not in set_example)  # 输出: True
# 定义一个元组
tuple_example = (100, 200, 300)
# 检查元素是否在元组中
print(200 in tuple_example)  # 输出: True
print(400 not in tuple_example)  # 输出: True


# 请详细说明python中的逻辑运算符and、or和not的用法，并举例说明它们在条件判断中的应用。
# 逻辑运算符是用于布尔值（True和False）之间进行逻辑操作的运算符。在Python中，主要有三个逻辑运算符：and、or和not。它们在条件判断中非常常用，下面详细说明它们的用法并举例说明。
# 1. and 运算符
# and 运算符用于连接两个条件表达式，只有当两个条件都为True时，整个表达式才为True；否则为False。
# 例子：
age = 25
has_license = True
if age >= 18 and has_license:
    print("You are eligible to drive.")
else:
    print("You are not eligible to drive.")
# 输出: You are eligible to drive.
# 2. or 运算符
# or 运算符用于连接两个条件表达式，只要其中一个条件为True，整个表达式就为True；只有当两个条件都为False时，整个表达式才为False。
# 例子：
is_raining = False
has_umbrella = True
if is_raining or has_umbrella:
    print("You can go outside.")
else:
    print("You should stay inside.")
# 输出: You can go outside.
# 3. not 运算符
# not 运算符用于取反一个布尔值，如果条件为True，not会将其变为False；如果条件为False，not会将其变为True。
# 例子：
is_sunny = False
if not is_sunny:
    print("It's not sunny today.")
else:
    print("It's sunny today.")
# 输出: It's not sunny today.
# 结合使用逻辑运算符
# 逻辑运算符可以结合使用，以构建更复杂的条件判断。
temperature = 30
is_humid = True
if (temperature > 25 and is_humid) or not is_humid:
    print("It's a hot day.")
else:
    print("It's a cool day.")
# 输出: It's a hot day.
# 总结
# 逻辑运算符and、or和not在Python中用于布尔值之间的逻辑操作。它们在条件判断中非常有用，可以帮助我们根据多个条件做出决策。通过合理使用这些运算符，可以编写出清晰且功能强大的条件语句。
# 类似js中的&& || !

"""
